# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Empresa Básica                             ##
 ##                                              ##
 ##                                              ##
 ##                                              ##
 ##   por Críptidos Digitales                    ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################

# print (0), "  equipos.igu           end"

from decimal import Decimal as dec
from PyQt4 import QtCore, QtGui

import frame_ui
import administradorEquipos_ui as administrador_ui
import capturaEquipo_ui as captura_ui
import detallesEquipo_ui as detalles_ui




import manejador



# print (0), "  equipos.igu             definitions"



class Forma(QtGui.QFrame):

    @property
    def app(self):
        return self.__app

    @property
    def owner(self):
        return self.__owner


    def __init__(self, *args, **kwds):
        m = "equipos.igu.__init__()"
        # print (1), m

        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)

        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)

        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)

        self.detalles = Detalles(self, owner=self)
        # self.detalles.hide()

        self.captura = Captura(self, owner=self)
        self.connect(self.captura, QtCore.SIGNAL("changed()"), self.changed)
        self.connect(self.captura, QtCore.SIGNAL("capturaClosed()"), self.capturaClosed)
        # self.connect(self.captura, QtCore.SIGNAL("clasificacionesChanged()"), self.clasificacionesChanged)
        self.captura.hide()

        self.administrador = Administrador(self, owner=self)
        self.connect(self.administrador, QtCore.SIGNAL("changed()"), self.changed)

        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL("handlePressed"), self.handlePressed)

        self.ui.outerSplitter.insertWidget(1, self.captura)

        # self.connect(self.parent(), QtCore.SIGNAL("proveedoresChanged()"), self.proveedoresChanged)
        self.connect(self.parent(), QtCore.SIGNAL("clientesChangedBroadcast"), self.clientesChangedBroadcast)

        self.ui.innerSplitter.setStretchFactor(0, 1)
        self.ui.innerSplitter.setStretchFactor(1, 0)

        self.ui.innerSplitter.setSizes([1, 0])

    def handlePressed(self):
        self.administrador.toggleDetalles()

    def capturaClosed(self):                # print "equipos.igu.Forma.capturaClosed()"
        self.ui.outerSplitter.setSizes([1,1])
        self.administrador.actualizaBotones()
        self.administrador.show()

    # def clasificacionesChanged(self):     # print "equipos.igu.Forma.clasificacionesChanged()"
        # self.emit(QtCore.SIGNAL("clasificacionesChanged()"))

    def changed(self):                      # print "equipos.igu.Forma.changed()"
        self.emit(QtCore.SIGNAL("equiposChanged()"))

    def clientesChangedBroadcast(self):     # print "equipos.igu.Forma.clientesChangedBroadcast()"
        self.emit(QtCore.SIGNAL("clientesChangedBroadcast()"))



class Administrador(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        # INICIALIZACION DE TABLA DE CONSULTA
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF;")
        self.ui.tablaConsulta.setColumnCount(6)
        self.ui.tablaConsulta.setHorizontalHeaderLabels([u"No. económico", u"Propietario", u"No. de serie", u"Placa", u"Marca, Línea y Modelo", u"Características"])
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(5, QtGui.QHeaderView.Stretch)

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("currentItemChanged(QTableWidgetItem *,QTableWidgetItem *)"), self.currentChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon, u"Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon, u"Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        # icon = QtGui.QIcon()
        # icon.addPixmap(QtGui.QPixmap("imagenes/Info.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        # self.ui.toInfo.setIcon(icon)
        # self.connect(self.ui.toInfo, QtCore.SIGNAL("enter()"), self.showInfo)
        # self.connect(self.ui.toInfo, QtCore.SIGNAL("leave()"), self.hideInfo)

        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        self.connect(self.parent(), QtCore.SIGNAL("equiposChanged()"), self.actualizaConsulta)

        self.actualizaConsulta()


    def actualizaBotones(self):
        self.aAgregar.setEnabled(True)
        self.aAgregar.setToolTip(u"Presiona para registrar un Equipo nuevo")

        if not self.owner.captura.isVisible():
            self.aAgregar.setChecked(False)
            self.aModificar.setChecked(False)
        self.aEliminar.setChecked(False)

        if self.ui.tablaConsulta.rowCount() == 0:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(u"No hay Equipos registrados")
            self.aEliminar.setEnabled(False)
            self.aEliminar.setToolTip(u"No hay Equipos registrados")
            # self.aImprimir.setEnabled(False)
            # self.aImprimir.setToolTip(u"No hay Equipos registrados")
        else:
            # self.aImprimir.setEnabled(True)
            # self.aImprimir.setToolTip(u"Se imprimen los Equipos listados solamente")
            if self.ui.tablaConsulta.currentRow() == -1:
                self.aModificar.setEnabled(False)
                self.aModificar.setToolTip(u"Selecciona el Equipo que quieres modificar")
                self.aEliminar.setEnabled(False)
                self.aEliminar.setToolTip(u"Selecciona el Equipo que quieres eliminar")
            else:
                self.aModificar.setEnabled(True)
                self.aModificar.setToolTip(u"Presiona para modificar los datos del Equipo seleccionado")
                self.aEliminar.setEnabled(True)
                self.aEliminar.setToolTip(u"Presiona para eliminar el Equipo seleccionado")
                # self.aImprimir.setEnabled(True  )
                # self.aImprimir.setToolTip(u"Presiona para Imprimir los Equipos enlistados")


    def actualizaConsulta(self):
        m = "equipos.igu.Administrador.actualizaConsulta()"

        old = self.currentId()

        registros = manejador.equiposI()

        self.ui.tablaConsulta.setRowCount(0)
        self.ui.tablaConsulta.setSortingEnabled(False)

        for index, dato in enumerate(registros):

            self.ui.tablaConsulta.insertRow(index)

            ## Código
            item = QtGui.QTableWidgetItem("%s" % (dato.codigo))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setData(1000, QtCore.QVariant(dato.id))
            self.ui.tablaConsulta.setItem(index, 0, item)

            ## Propietario
            item = QtGui.QTableWidgetItem("%s %s" % (dato.propietario.entidad.nombre, dato.propietario.entidad.nombre2))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(index, 1, item)

            ## Serie
            item = QtGui.QTableWidgetItem(dato.serie)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(index, 2, item)

            ## Placa
            item = QtGui.QTableWidgetItem(dato.registro)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(index, 3, item)

            ## Marca, Linea, Modelo
            item = QtGui.QTableWidgetItem("%s %s %s" % (dato.marca.nombre, dato.linea.nombre, dato.modelo.nombre))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setData(1000, QtCore.QVariant(dato.marca.code))
            item.setData(1001, QtCore.QVariant(dato.linea.code))
            item.setData(1002, QtCore.QVariant(dato.modelo.code))
            self.ui.tablaConsulta.setItem(index, 4, item)

            ## Características
            item = QtGui.QTableWidgetItem(dato.color)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(index, 5, item)

        self.ui.tablaConsulta.setSortingEnabled(True)

        self.setCurrentId(old)

        self.actualizaBotones()

        self.ui.tablaConsulta.resizeColumnToContents(0)
        self.ui.tablaConsulta.resizeColumnToContents(2)
        self.ui.tablaConsulta.resizeColumnToContents(3)


    def agrega(self):
        self.owner.captura.agrega()


    def currentChanged(self, new, old):     # print "equipos.igu.Administrador.currentChanged()"
        if new and not old:
            self.toggleDetalles()


    def currentId(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        else:
            id = None
        return id


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar equipo", u"Selecciona el EQUIPO que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            datos = manejador.dameUno(id=id)

            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar equipo", u"¿Realmente quieres ELIMINAR el EQUIPO %s %s %s %s?" % (datos.tipo, datos.marca, datos.linea, datos.modelo), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                manejador.elimina(id=id)
                self.emit(QtCore.SIGNAL("changed()"))

    def findData(self, data):
        index = -1
        for row in range(self.ui.tablaConsulta.rowCount()):
            if self.ui.tablaConsulta.item(row, 0).data(1000)==QtCore.QVariant(data):
                index = row
        return index

    def hideInfo(self):
        self.frame.hide()

    def modifica(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar equipo", u"Seleccione el EQUIPO que quiere MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.captura.modifica(id)

    # def mostrarDetalles(self, item):
        # id = self.ui.tablaConsulta.item(item.row(), 0).data(1000).toInt()[0]
        # self.owner.detalles.mostrar(id)

    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)

    def selectionChanged(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if self.owner.detalles.isVisible():
                self.owner.detalles.mostrar(id)
            if self.owner.captura.isVisible():
                if self.owner.captura.modo == 'modifica':
                    if self.owner.captura.id != id:
                        if self.owner.captura.estaModificado():
                            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Equipo", u"La captura de Equipo tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.tipo, self.owner.captura.old.propietario_id), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                            if result == QtGui.QMessageBox.Yes:
                                self.owner.captura.guardar(hide=False)
                        self.owner.captura.modifica(id)
        self.actualizaBotones()


    def setCurrentId(self, id):
        self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))


    def showInfo(self):                 # print "productos.igu.Administrador.showInfo()"
        pos = self.ui.toInfo.pos()
        pos.setX(pos.x()+self.ui.toInfo.width())
        pos.setY(pos.y()-self.frame.height()+100)
        self.frame.move(pos)
        self.frame.setText("Taaaaaaaaaaaaaaaaaaaaaaaaan")
        self.frame.show()

    def toggleDetalles(self, *args):
        if self.owner.ui.innerSplitter.sizes()[1]:
            self.owner.ui.innerSplitter.setSizes([1, 0])
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.detalles.mostrar(id)
            self.owner.ui.innerSplitter.setSizes([1, 100])



class Captura(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner

    @property
    def modo(self):
        return self.__modo

    def __init__(self, *args, **kwds):          # print "equipos.igu.Captura.__init__()"
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        ## Tipo
        self.ui.edTipo.setAllowedLengths(4, 50)
        self.connect(self.ui.edTipo, QtCore.SIGNAL("textEdited()"),self.validarTipo)
        self.connect(self.ui.edTipo, QtCore.SIGNAL("statusChanged()"), self.validarTipo)

        ## Color
        self.ui.edColor.setEmptyAllowed(True)
        self.connect(self.ui.edColor, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Serie
        self.connect(self.ui.edSerie, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Clave2
        self.connect(self.ui.edClave2, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Origen
        self.connect(self.ui.edOrigen, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Propietario
        clienteCompleter = QtGui.QCompleter([], self.ui.edPropietario)
        self.modeloCliente = ModeloClientes()
        clienteCompleter.setModel(self.modeloCliente)
        clienteCompleter.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.connect(clienteCompleter, QtCore.SIGNAL("activated(QModelIndex)"), self.clienteSeleccionado)
        self.ui.edPropietario.setCompleter(clienteCompleter)
        self.connect(self.ui.edPropietario, QtCore.SIGNAL("textEdited(QString)"), self.clienteEditado)
        self.connect(self.ui.edPropietario, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Accesorios
        self.connect(self.ui.teAccesorios, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        ## Observaciones
        self.connect(self.ui.edObservaciones, QtCore.SIGNAL("editingFinished()"), self.actualizaStatus)

        self.propietario = None

        ## Se carga los clientes al inicio, cualquier actualización se reflejará automáticamente mediante un broadcast.
        # self.cargarClientes()


        # self.ui.edMarca.setAllowedLengths(0, 30)

        # self.ui.edLinea.setAllowedLengths(0, 40)
        # self.ui.edLinea.setEmptyAllowed(True)

        # self.ui.edModelo.setAllowedLengths(0, 20)

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuardar.setIcon(icon)
        self.ui.boGuardar.setIconSize(QtCore.QSize(32,32))
        self.ui.boGuardar.setEnabled(False)
        QtCore.QObject.connect(self.ui.boGuardar, QtCore.SIGNAL("clicked()"), self.guarda)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,32))
        QtCore.QObject.connect(self.ui.boCancelar, QtCore.SIGNAL("clicked()"), self.cancelar)

        QtCore.QObject.connect(self.parent(), QtCore.SIGNAL("clientesChangedBroadcast()"), self.cargarClientes)


    def actualizaStatus(self, *args):
        if self.modo == "modificar":
            if self.estaModificado():
                if self.esValida():
                    self.ui.boGuardar.setEnabled(True)
                    self.ui.boGuardar.setToolTip(u"")
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")
            else:
                self.ui.boGuardar.setEnabled(False)
                self.ui.boGuardar.setToolTip(u"No hay cambios")
        else:
            if self.esValida():
                self.ui.boGuardar.setEnabled(True)
            else:
                self.ui.boGuardar.setEnabled(False)
            self.ui.boGuardar.setToolTip(self.mensajes)


    def agrega(self):
        self.__modo = "agrega"
        self.clear()
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Alta de Equipo", None, QtGui.QApplication.UnicodeUTF8))
        self.actualizaStatus()
        self.ui.edTipo.setFocus()
        self.show()


    def cancelar(self):
        self.clear()
        self.hide()
        self.emit(QtCore.SIGNAL("capturaClosed()"))


    def cargarClientes(self, texto=""):
        # print "equipos.igu.Captura.cargarClientes()"
        if texto:
            clientes = manejador.dameClientes({'nombre':texto})
        else:
            clientes = manejador.dameClientes()
        self.ui.edPropietario.completer().model().clear()
        for row, cliente in enumerate(clientes):
            self.ui.edPropietario.completer().model().insertRow(row)
            index = self.ui.edPropietario.completer().model().index(row, 0)
            self.ui.edPropietario.completer().model().setData(index, QtCore.QVariant("%s %s" % (cliente.entidad.nombre, cliente.entidad.nombre2)), QtCore.Qt.DisplayRole)
            self.ui.edPropietario.completer().model().setData(index, cliente.id, QtCore.Qt.UserRole)

    # def cargarClientes(self):
        # self.ui.edPropietario.clear()
        # entidades = manejador.dameClientes()
        # if entidades:
            # self.ui.edPropietario.addItem("Seleccione uno")
            # for entidad in entidades:
                # self.ui.edPropietario.addItem("%s %s" % (entidad['nombres'], entidad['apellidos']))
        # else:
            # self.ui.edPropietario.addItem("Debe dar de alta al cliente")


    def clear(self):
        self.ui.edTipo.clear()
        self.ui.edColor.clear()
        self.ui.edSerie.clear()
        self.ui.edClave2.clear()
        self.ui.edOrigen.clear()
        self.ui.edPropietario.clear()
        self.ui.teAccesorios.clear()
        self.ui.edObservaciones.clear()


    def clienteEditado(self, texto):
        if len(texto) == 1:
            self.cargarClientes(texto)


    def clienteSeleccionado(self, completerModelIndex):
        # print "equipos.igu.Captura.clienteSeleccionado()"
        data = self.sender().completionModel().data(completerModelIndex, QtCore.Qt.UserRole).toInt()[0]

        self.propietario = manejador.dameCliente({'id':data})
        # self.ui.edCalle.setText("%s   %s" % (self.cliente.direcciones[0].calle, self.cliente.direcciones[0].areanominal))
        # self.ui.edLugar.setText(self.cliente.direcciones[0].lugar)
        # self.ui.edRFC.setText(self.cliente.entidad.rfc)


    def datos(self):
        datos = {}
        if self.modo == 'modifica':
            datos['id'] = self.id
        datos['tipo'] = unicode(self.ui.edTipo.text())
        datos['serie'] = unicode(self.ui.edSerie.text())
        datos['clave2'] = unicode(self.ui.edClave2.text())
        datos['otros'] = unicode(self.ui.edColor.text())
        if self.propietario:
            datos['propietario_id'] = self.propietario.id
        datos['accesorios'] = unicode(self.ui.teAccesorios.toPlainText())
        return datos


    def estaModificado(self):
        data = self.data()
        try:
            if self.old.tipo==data['tipo'] and self.old.color==data['color'] and self.old.producto.serie==data['serie'] and self.old.clave2.tipo==data['clave2'] and self.old.producto.origen==data['origen'] and self.old.propietario_id==data['propietario_id'] and self.old.accesorios==data['accesorios'] and self.old.observaciones==data['observaciones']:
                return False
            else:
                return True
        except:
            return True


    def esValida(self):
        valida = True
        self.mensajes = ""

        if not self.ui.edTipo.isValid:
            valida = False
            self.mensajes += u"%s en el tipo\n" % self.ui.edTipo.message()

        if self.ui.edPropietario.text().isEmpty():
            valida = False
            self.mensajes += u"Debe seleccionar un propietario\n"

        # validaTemp, mensajes = manejador.valida(self.data, self.modo)
        # if not validaTemp:
            # valida = False
            # self.mensajes += mensajes

        return valida


    def guarda(self, **kwds):
        if self.esValida():
            datos = self.datos()
            if self.modo == "agrega":
                manejador.agrega(datos)
            elif self.modo == "modifica":
                manejador.modifica(datos)
            self.clear()
            self.emit(QtCore.SIGNAL("changed()"))
            self.emit(QtCore.SIGNAL("capturaClosed()"))
            self.hide()
            # self.parent().setSizes([1,1])
            self.owner.administrador.ui.tablaConsulta.setCurrentCell(self.owner.administrador.findData(id), 0)
        else:
            QtGui.QMessageBox.warning(self, u"Empresa Básica - Equipos", u"%s" % self.mensajes, QtGui.QMessageBox.Ok)


    def modifica(self, id):
        self.id = id
        self.__modo = "modifica"
        self.clear()
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Equipo", None, QtGui.QApplication.UnicodeUTF8))
        data = manejador.dameUno(id=id)
        self.setData(data)
        self.actualizaStatus()
        self.ui.edTipo.setFocus()
        self.show()


    def setData(self, data):            # print "equipos.igu.Captura.setData()"
        self.old = data
        self.ui.edTipo.setText(data.tipo)
        self.ui.edColor.setText(data.color)
        self.ui.edSerie.setText(data.serie)
        self.ui.edClave2.setText(data.clave2)
        self.ui.edOrigen.setText(data.origen)
        self.ui.edPropietario.setText("%s %s" % (data.propietario.nombre, data.propietario.nombre2))
        self.ui.teAccesorios.setText(data.accesorios)
        self.ui.edObservaciones.setText(data.observaciones)
        self.propietario = data.propietario


    def validarTipo(self):
        # acepcion = manejador.dameUno(tipo=unicode(self.ui.edTipo.text()))
        # self.ui.edTipo.setExternalValidation(True, u"")
        # if acepcion:
            # if self.modo == 'modificar' and acepcion.id == self.id:
                # pass
            # else:
                # self.ui.edTipo.setExternalValidation(False, u"El tipo ya existe\n")
        self.actualizaStatus()



class Detalles(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner


    def __init__(self, *args, **kwds):

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)



    def mostrar(self, id):
        data = manejador.equipoI(id=id)
        self.setData(data)
        self.show()


    def setData(self, data):
        self.ui.laCodigo.setText(data.codigo)
        self.ui.laDescripcion.setText("%s %s %s" % (data.marca.nombre, data.linea.nombre, data.modelo.nombre))
        self.ui.laIdentificacion.setText("Placa %s   No. Serie %s" % (data.registro, data.serie))
        self.ui.laCaracteristicas.setText(data.color)

        self.ui.laPropietario.setText("%s %s" % (data.propietario.entidad.nombre, data.propietario.entidad.nombre2))


class ModeloClientes(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        print "equipos.igu.ModeloClientes().data()"
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            print "DisplayRole"
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            print "TextAlignmentRole"
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == QtCore.Qt.UserRole:
            print "UserRole"
            return self.__data[index.row()][1]
        else:
            print role
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):
        print "equipos.igu.ModeloClientes.insertRow()"
        self.__data.insert(row, [QtCore.QVariant(""), QtCore.QVariant("")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def reload(self):
        pass


    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            print "QtCore.Qt.DisplayRole"
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            print "QtCore.Qt.UserRole"
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True



class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event):       # print "Handle.mousePressEvent()"
        self.emit(QtCore.SIGNAL("handlePressed"))


# print (0), "  equipos.igu           end"


"""
        self.ui.slideDetalles = cdSlideFrame.CDSlideFrame(self.ui.tablaConsulta, self.ui.layoutDetalles, orientation="horizontal", container=self.ui.containerDetalles)
        self.ui.slideDetalles.ui = detallesEquipo_ui.Ui_Form()
        self.ui.slideDetalles.ui.setupUi(self.ui.slideDetalles)
        self.ui.slideDetalles.setStyleSheet("background-color:#EFEFEF")

        # Referente a slideCaptura
        self.ui.slideCaptura = cdSlideFrame.CDSlideFrame(self.ui.tablaConsulta, self.ui.layoutCaptura, orientation="vertical", container=self.ui.containerCaptura)
        self.ui = capturaEquipo_ui.Ui_Form()
        self.ui.setupUi(self.ui.slideCaptura)
        self.ui.frame.setStyleSheet("background-color:#FFFFFF")

"""